// -*- Mode: C++; -*-
// TinyCl - Symbols
// tinycl_syms.inc
//
// Copyright (C) 2007-2008 by Project Vogue.
// Written by Yoshifumi "VOGUE" INOUE. (yosi@msn.com)
//
// @(#)$Id: //proj/evedit2/mainline/tinycl/tinycl_syms.inc#74 $
//
#include "./tinycl_begin_list.h"

// [+]
definternal(si,  Pstandard_method_combinationP,
    "+STANDARD-METHOD-COMBINATION+" )

// [*]
definternal(si,  Acaller_tableA,                "*CALLER-TABLE*")
definternal(si,  Achar_name_tableA,             "*CHAR-NAME-TABLE*")
definternal(si,  Acharset_tableA,               "*CHARSET-TABLE*")
definternal(si,  Acommand_line_argumentsA,      "*COMMAND-LINE-ARGUMENTS*")
definternal(si,  Adefault_external_formatA,     "*DEFAULT-EXTERNAL-FORMAT*")
definternal(si,  Adll_file_tableA,              "*DLL-FILE-TABLE*")
definternal(si,  AenvironmentA,                 "*ENVIRONMENT*")
definternal(si,  Aexternal_formatA,             "*EXTERNAL-FORMAT*")
definternal(si,  Aimage_save_timeA,             "*IMAGE-SAVE-TIME*")
definternal(si,  Aname_char_tableA,             "*NAME-CHAR-TABLE*")
definternal(si,  ApackagesA,                    "*PACKAGES*")
definternal(si,  Apathname_hostsA,              "*PATHNAME-HOSTS*")
definternal(si,  Aread_backquoteA,              "*READ-BACKQUOTE*")
definternal(si,  Aread_line_number_tableA,      "*READ-LINE-NUMBER-TABLE*")
definternal(si,  Aread_start_line_numberA,      "*READ-START-LINE-NUMBER*")
definternal(si,  Arestart_clustersA,            "*RESTART-CLUSTERS*")
definternal(si,  Aruntime_environmentA,         "*RUNTIME-ENVIRONMENT*")
definternal(si,  Asetf_tableA,                  "*SETF-TABLE*")
definternal(si,  Astandard_readtableA,          "*STANDARD-READTABLE*")
definternal(si,  Atlv_indexA,                   "*TLV-INDEX*")
definternal(si,  Atlv_vectorA,                  "*TLV-VECTOR*")
definternal(si,  Avalue_tableA,                 "*VALUE-TABLE*")

definternal(si,  _S1, "-/1")
definternal(si,  SS1, "//1")

definternal(si,  PS2, "+/2")
definternal(si,  _S2, "-/2")
definternal(si,  AS2, "*/2")
definternal(si,  SS2, "//2")

definternal(si,  GS2,   ">/2")
definternal(si,  GQS2,  ">=/2")
definternal(si,  LS2,   "</2")
definternal(si,  LQS2,  "<=/2")
definternal(si,  QS2,   "=/2")
definternal(si,  SQS2,  "/=/2")

// [A]
definternal(si,  address_of,        "ADDRESS-OF")
definternal(si,  aliases,           "ALIASES")
definternal(si,  allocation,        "ALLOCATION")
definternal(si,  allocate_binobj,   "ALLOCATE-BINOBJ")
definternal(si,  allocate_binvec,   "ALLOCATE-BINVEC")
definternal(si,  allocate_record,   "ALLOCATE-RECORD")
defexternal(ext, already_realized,  "ALREADY-REALIZED")
definternal(si,  appendS2,          "APPEND/2")
definternal(si,  array_object,      "ARRAY-OBJECT")
definternal(si,  arguments,         "ARGUMENTS")
definternal(si,  assq,              "ASSQ")

// [B]
definternal(si,  backquote,                 "BACKQUOTE")
definternal(si,  basic_host,                "BASIC-HOST")
definternal(si,  bit_vector_object,         "BIT-VECTOR-OBJECT")
definternal(si,  blob,                      "BLOB")
definternal(si,  bool,                      "BOOL")     // foreign type
defexternal(ext, bounding_index_error,      "BOUNDING-INDEX-ERROR")
definternal(si,  byte_specifier,            "BYTE-SPECIFIER")

// [C]
definternal(si,  captures,                  "CAPTURES")
definternal(si,  char6,                     "CHAR16")    // foreign type
definternal(si,  char8,                     "CHAR8")     // foreign type
definternal(si,  charGS2,                   "CHAR>/2")
definternal(si,  charGQS2,                  "CHAR>=/2")
definternal(si,  charLS2,                   "CHAR</2")
definternal(si,  charLQS2,                  "CHAR<=/2")
definternal(si,  charQS2,                   "CHAR=/2")
definternal(si,  charSQS2,                  "CHAR/=/2")
definternal(si,  char_category,             "CHAR-CATEGORY")
definternal(si,  char_equalS2,              "CHAR-EQUAL/2")
definternal(si,  char_not_equalS2,          "CHAR-NOT-EQUAL/2")
definternal(si,  char_greaterpS2,           "CHAR-GREATERP/2")
definternal(si,  char_not_greaterpS2,       "CHAR-NOT-GREATERP/2")
definternal(si,  char_lesspS2,              "CHAR-LESSP/2")
definternal(si,  char_not_lesspS2,          "CHAR-NOT-LESSP/2")
definternal(si,  charset,                   "CHARSET")
definternal(si,  check_keywords,            "CHECK-KEYWORDS")
definternal(si,  class_description,         "CLASS-DESCRIPTION")
definternal(si,  classd_of,                 "CLASSD-OF")
definternal(si,  class_not_finalized,       "CLASS-NOT-FINALIZED")
definternal(si,  classes,                   "CLASSES")
definternal(si,  closed_cell,               "CLOSED-CELL")
definternal(si,  code,                      "CODE")
definternal(si,  code_index,                "CODE-INDEX")
definternal(si,  code_page,                 "CODE-PAGE")
definternal(si,  collect_garbage,           "COLLECT-GARBAGE")
definternal(si,  column,                    "COLUMN")
definternal(si,  compile_regex,             "COMPILE-REGEX")
definternal(si,  compute_discriminator,     "COMPUTE-DISCRIMINATOR")
definternal(si,  compute_effective_method_using_arguments,
    "COMPUTE-EFFECTIVE-METHOD-USING-ARGUMENTS" )
definternal(si,  condition_designator,      "CONDITION-DESIGNATOR")
definternal(si,  console_stream,            "CONSOLE-STREAM")
definternal(si,  cookie,                    "COOKIE")
definternal(si,  coerceSbignumSfloat32,     "COERCE/BIGNUM/FLOAT32")
definternal(si,  coerceSbignumSfloat64,     "COERCE/BIGNUM/FLOAT64")
definternal(si,  customary_case,            "CUSTOMARY-CASE")

// [D]
definternal(si,  data,                      "DATA")
definternal(si,  data_vector,               "DATA-VECTOR")
definternal(si,  datum,                     "DATUM")
definternal(si,  default_device,            "DEFAULT-DEVICE")
definternal(si,  default_emf,               "DEFAULT-EMF")
definternal(si,  device,                    "DEVICE")
definternal(si,  direct_methods,            "DIRECT-METHODS")
definternal(si,  direct_slots,              "DIRECT-SLOTS")
definternal(si,  direct_subclasses,         "DIRECT-SUBCLASSES")
definternal(si,  direct_superclasses,       "DIRECT-SUPERCLASSES")
definternal(si,  displaced_to,              "DISPLACED-TO")
definternal(si,  dll_file_info,             "DLL-FILE-INFO")
definternal(si,  dll_link_error,            "DLL-LINK-ERROR")
definternal(si,  dll_proc_info,             "DLL-PROC-INFO")
definternal(si,  double_float_complex,      "DOUBLE-FLOAT-COMPLEX")
definternal(si,  double_float_complex_vector,"DOUBLE-FLOAT-COMPLEX-VECTOR")
definternal(si,  double_float_vector,       "DOUBLE-FLOAT-VECTOR")

// [E]
definternal(si,  element_size,              "ELEMENT-SIZE")
definternal(si,  element_type,              "ELEMENT-TYPE")
definternal(si,  end,                       "END")
definternal(si,  entry,                     "ENTRY")
definternal(si,  environment,               "ENVIRONMENT")
definternal(si,  eol,                       "EOL")
definternal(si,  eql_caches,                "EQL-CACHES")
defexternal(ext, exit_lisp,                 "EXIT-LISP")
definternal(si,  expected_type,             "EXPECTED-TYPE")
definternal(si,  extra_length,              "EXTRA-LENGTH")
defexternal(ext, external_format,           "EXTERNAL-FORMAT")
definternal(si,  external_table,            "EXTERNAL-TABLE")

// [F]
definternal(si,  file_not_found,            "FILE-NOT-FOUND")
definternal(si,  find_setf_cell,            "FIND-SETF-CELL")
definternal(si,  find_value_cell,           "FIND-VALUE-CELL")
definternal(si,  fixed_size,                "FIXED-SIZE")
definternal(si,  flags,                     "FLAGS")
definternal(si,  float32,                   "FLOAT32")  // foreign type
definternal(si,  float64,                   "FLOAT64")  // foreign type
definternal(si,  form,                      "FORM")
definternal(si,  format_arguments,          "FORMAT-ARGUMENTS")
definternal(si,  format_control,            "FORMAT-CONTROL")
definternal(si,  funcallable,               "FUNCALLABLE")
definternal(si,  funcallable_instance,      "FUNCALLABLE-INSTANCE")
defexternal(ext, function_designator,       "FUNCTION-DESIGNATOR")
definternal(si,  function_information,      "FUNCTION-INFORMATION")
defexternal(ext, function_name,             "FUNCTION-NAME")
definternal(si,  functions,                 "FUNCTIONS")

// [H]
definternal(si,  handle,                    "HANDLE")
definternal(si,  hash_code,                 "HASH-CODE")
definternal(si,  host,                      "HOST")
defexternal(ext, html_encode_stream,        "HTML-ENCODE-STREAM")

// [I]
definternal(si,  identity_with_one_argument,"IDENTITY-WITH-ONE-ARGUMENT")
definternal(si,  imag,                      "IMAG")
definternal(si,  index,                     "INDEX")
definternal(si,  index_error,               "INDEX-ERROR")
definternal(si,  initargs,                  "INITARGS")
definternal(si,  initform,                  "INITFORM")
definternal(si,  initfunction,              "INITFUNCTION")
defexternal(ext, input_stream,              "INPUT-STREAM")
defexternal(ext, input_stream_designator,   "INPUT-STREAM-DESIGNATOR")
definternal(si,  install_method,            "INSTALL-METHOD")
definternal(si,  instance,                  "INSTANCE")
definternal(si,  instance_description,      "INSTANCE-DESCRIPTION")
definternal(si,  int,                       "INT")      // foreign type
definternal(si,  int16,                     "INT16")    // foreign type
definternal(si,  int32,                     "INT32")    // foreign type
definternal(si,  int64,                     "INT64")    // foreign type
definternal(si,  int8,                      "INT8")     // foreign type
definternal(si,  interactive_function,      "INTERACTIVE-FUNCTION")
definternal(si,  intern_setf_cell,          "INTERN-SETF-CELL")
definternal(si,  intern_value_cell,         "INTERN-VALUE-CELL")
definternal(si,  internal_table,            "INTERNAL-TABLE")
definternal(si,  invalid_keyword_argument,  "INVALID-KEYWORD-ARGUMENT")
definternal(si,  invalid_object,            "INVALID-OBJECT")
definternal(si,  io_stream,                 "IO-STREAM")

// [K]
definternal(si,  key,                       "KEY")
definternal(si,  keys,                      "KEYS")
definternal(si,  kind,                      "KIND")

// [L]
definternal(si,  lambda_list,               "LAMBDA-LIST")
definternal(si,  latch,                     "LATCH")
definternal(si,  line_column,               "LINE-COLUMN")
definternal(si,  line_number,               "LINE-NUMBER")
definternal(si,  line_size,                 "LINE-SIZE")
definternal(si,  local_case,                "LOCAL-CASE")
definternal(si,  location,                  "LOCATION")
definternal(si,  logandS2,                  "LOGAND/2")
definternal(si,  logeqvS2,                  "LOGEQV/2")
definternal(si,  logical_host,              "LOGICAL-HOST")
definternal(si,  logiorS2,                  "LOGIOR/2")
definternal(si,  logxorS2,                  "LOGXOR/2")

// [M]
definternal(si,  make_not_function_function, "MAKE-NOT-FUNCTION-FUNCTION")
definternal(si,  make_pathname_using_host,   "MAKE-PATHNAME-USING-HOST")
definternal(si,  make_undefined_function_function, "MAKE-UNDEFINED-FUNCTION-FUNCTION")
defexternal(si,  make_stack_trace,          "MAKE-STACK-TRACE")
definternal(si,  make_vector,               "MAKE-VECTOR")

#define definternal_mapX(mp_name, mp_NAME) \
    definternal(si,  mp_name ## S1, mp_NAME "/1") \
    definternal(si,  mp_name ## S2, mp_NAME "/2") \
    definternal(si,  mp_name ## S3, mp_NAME "/3") \
    definternal(si,  mp_name ## S4, mp_NAME "/4")

    definternal_mapX(mapc,      "MAPC")
    definternal_mapX(mapcan,    "MAPCAN")
    definternal_mapX(mapcar,    "MAPCAR")
    definternal_mapX(mapcon,    "MAPCON")
    definternal_mapX(mapl,      "MAPL")
    definternal_mapX(maplist,   "MAPLIST")

#undef definternal_mapX

definternal(si,  marker,                    "MARKER")
defexternal(ext, match_end,                 "MATCH-END")
defexternal(ext, match_group_count,         "MATCH-GROUP-COUNT")
defexternal(ext, match_start,               "MATCH-START")
defexternal(ext, match_string,              "MATCH-STRING")
defexternal(ext, matched_p,                 "MATCHED-P")
definternal(si,  max_params,                "MAX-PARAMS")
definternal(si,  memq,                      "MEMQ")
definternal(si,  method_cache,              "METHOD-CACHE")
definternal(si,  method_class,              "METHOD-CLASS")
definternal(si,  methods,                   "METHODS")
definternal(si,  mime_name,                 "MIME-NAME")
definternal(si,  min_params,                "MIN-PARAMS")
definternal(si,  mode,                      "MODE")

// [N]
definternal(si,  name,                      "NAME")
definternal(si,  names,                     "NAMES")
definternal(si,  native_code_closure,       "NATIVE-CODE-CLOSURE")
definternal(si,  native_code_function,      "NATIVE-CODE-FUNCTION")
definternal(si,  native_code_object,        "NATIVE-CODE-OBJECT")
definternal(si,  nconcS2,                   "NCONC/2")
defexternal(ext, next_match,                "NEXT-MATCH")
definternal(si,  next_match_using_source,   "NEXT-MATCH-USING-SOURCE")
definternal(si,  not_function,              "NOT-FUNCTION")
definternal(si,  not_function_function,     "NOT-FUNCTION-FUNCTION")
defexternal(ext, not_realized,              "NOT-REALIZED")

// [O]
definternal(si,  object,                     "OBJECT")
definternal(si,  odd_number_of_keyword_arguments, "ODD-NUMBER-OF-KEYWORD-ARGUMENTS")
definternal(si,  offset,                     "OFFSET")
definternal(si,  operation,                  "OPERATION")
definternal(si,  operator,                   "OPERATOR")
definternal(si,  operands,                   "OPERANDS")
definternal(si,  options,                    "OPTIONS")
definternal(si,  order,                      "ORDER")
definternal(si,  others,                     "OTHERS")
definternal(si,  outer,                      "OUTER")
defexternal(ext, output_stream,              "OUTPUT-STREAM")
defexternal(ext, output_stream_designator,   "OUTPUT-STREAM-DESIGNATOR")

// [P]
defexternal(ext, package_designator,            "PACKAGE-DESIGNATOR")
definternal(si,  pad,                           "PAD")
defexternal(ext, pathname_designator,           "PATHNAME-DESIGNATOR")
defexternal(ext, pathname_device_designator,    "PATHNAME-DEVICE-DESIGNATOR")
defexternal(ext, pathname_directory_designator, "PATHNAME-DIRECTORY-DESIGNATOR")
definternal(si,  pathname_equal,                "PATHNAME-EQUAL")
defexternal(ext, pathname_host_designator,      "PATHNAME-HOST-DESIGNATOR")
defexternal(ext, pathname_name_designator,      "PATHNAME-NAME-DESIGNATOR")
defexternal(ext, pathname_type_designator,      "PATHNAME-TYPE-DESIGNATOR")
defexternal(ext, pathname_version_designator,   "PATHNAME-VEERSION-DESIGNATOR")
definternal(si,  parse_namestring_using_host,   "PARSE-NAMESTRING-USING-HOST")
definternal(si,  path_not_found,                "PATH-NOT-FOUND")
definternal(si,  pathname_host_not_found,       "PATHNAME-HOST-NOT-FOUND")
definternal(si,  pathname_not_matched,          "PATHNAME-NOT-MATCHED")
definternal(si,  pathname_parse_error,          "PATHNAME-PARSE-ERROR")
definternal(si,  pattern,                       "PATTERN")
definternal(si,  physical_host,                 "PHYSICAL-HOST")
definternal(si,  physical_pathname,             "PHYSICAL-PATHNAME")
definternal(si,  platform_error,                "PLATFORM-ERROR")
definternal(si,  platform_stream,               "PLATFORM-STREAM")
definternal(si,  plist,                         "PLIST")
definternal(si,  pprint_dispatch_table,         "PPRINT-DISPATCH-TABLE")
defexternal(ext, proper_list,                   "PROPER-LIST")
definternal(si,  protect,                       "PROTECT")
definternal(si,  prototype,                     "PROTOTYPE")
definternal(si,  ptr,                           "PTR")  // foreign type

// [Q]
definternal(si,  qualifiers,            "QUALIFIERS")

// [R]
defexternal(ext, range,                 "RANGE")
defexternal(ext, range_string,          "RANGE-STRING")
definternal(si,  rank,                  "RANK")
definternal(si,  rational_complex,      "RATIONAL-COMPLEX")
definternal(si,  reader_eof_error,      "READER-EOF-ERROR")
definternal(si,  readers,               "READERS")
definternal(si,  read_only,             "READ-ONLY")
definternal(si,  record_object,         "RECORD-OBJECT")
defexternal(ext, regex,                 "REGEX")
defexternal(ext, regex_match,           "REGEX-MATCH")
definternal(si,  rehash_size,           "REHASH-SIZE")
defexternal(ext, realize_instance,      "REALIZE-INSTANCE")
definternal(si,  report_function,       "REPORT-FUNCTION")
defexternal(ext, restart_designator,    "RESTART-DESIGNATOR")

// [S]
definternal(si,  save_image,                "SAVE-IMAGE")
definternal(si,  setf_cell,                 "SETF-CELL")
defexternal(ext, sequence_end,              "SEQUENCE-END")
defexternal(ext, sequence_index,            "SEQUENCE-INDEX")
defexternal(ext, sequence_index_error,      "SEQUENCE-INDEX-ERROR")
definternal(si,  shadowing_symbols,         "SHADOWING-SYMBOLS")
definternal(si,  simple_reader_error,       "SIMPLE-READER-ERROR")
definternal(si,  signed_byte_8_vector,      "SIGNED-BYTE-8-VECTOR")
definternal(si,  signed_byte_16_vector,     "SIGNED-BYTE-16-VECTOR")
definternal(si,  signed_byte_32_vector,     "SIGNED-BYTE-32-VECTOR")
definternal(si,  single_float_complex,      "SINGLE-FLOAT-COMPLEX")
definternal(si,  single_float_complex_vector,"SINGLE-FLOAT-COMPLEX-VECTOR")
definternal(si,  single_float_vector,       "SINGLE-FLOAT-VECTOR")
definternal(si,  size,                      "SIZE")
definternal(si,  slots,                     "SLOTS")
definternal(si,  source,                    "SOURCE")
definternal(si,  specializers,              "SPECIALIZERS")
definternal(si,  start,                     "START")
defexternal(si,  stack_frame,               "STACK-FRAME")
definternal(si,  start_application,         "START-APPLICATION")
defexternal(ext, start_match,               "START-MATCH")
definternal(si,  standard_base_class,       "STANDARD-BASE-CLASS")
defexternal(ext, stream_advance_to_column,  "STREAM-ADVANCE-TO-COLUMN")
defexternal(ext, stream_clear_input,        "STREAM-CLEAR-INPUT")
defexternal(ext, stream_clear_output,       "STREAM-CLEAR-OUTPUT")
defexternal(ext, stream_finish_output,      "STREAM-FINISH-OUTPUT")
defexternal(ext, stream_force_output,       "STREAM-FORCE-OUTPUT")
defexternal(ext, stream_fresh_line,         "STREAM-FRESH-LINE")
defexternal(ext, stream_line_column,        "STREAM-LINE-COLUMN")
defexternal(ext, stream_line_number,        "STREAM-LINE-NUMBER")
defexternal(ext, stream_listen,             "STREAM-LISTEN")
defexternal(ext, stream_pathname,           "STREAM-PATHNAME")
defexternal(ext, stream_peek_char,          "STREAM-PEEK-CHAR")
defexternal(ext, stream_read_char,          "STREAM-READ-CHAR")
defexternal(ext, stream_read_char_no_hand,  "STREAM-READ-CHAR-NO-HANG")
defexternal(ext, stream_read_line,          "STREAM-READ-LINE")
defexternal(ext, stream_read_sequence,      "STREAM-READ-SEQUENCE")
defexternal(ext, stream_start_line_p,       "STREAM-START-LINE-P")
defexternal(ext, stream_terpri,             "STREAM-TERPRI")
defexternal(ext, stream_unread_char,        "STREAM-UNREAD-CHAR")
defexternal(ext, stream_write_byte,         "STREAM-WRITE-BYTE")
defexternal(ext, stream_write_char,         "STREAM-WRITE-CHAR")
defexternal(ext, stream_write_sequence,     "STREAM-WRITE-SEQUENCE")
defexternal(ext, stream_write_string,       "STREAM-WRITE-STRING")
defexternal(ext, string_designator,         "STRING-DESIGNATOR")
defexternal(ext, string_input_stream,       "STRING-INPUT-STREAM")
definternal(si,  string_match,              "STRING-MATCH")
definternal(si,  string_object,             "STRING-OBJECT")
definternal(si,  string_output_stream,      "STRING-OUTPUT-STREAM")
definternal(si,  string_range,              "STRING-RANGE")
definternal(si,  structure_direct_slot_definition,   "STRUCTURE-DIRECT-SLOT-DEFINITION")
definternal(si,  structure_effective_slot_definition,   "STRUCTURE-EFFECTIVE-SLOT-DEFINITION")
definternal(si,  structure_slot_definition, "STRUCTURE-SLOT-DEFINITION")
definternal(si,  storage,                   "STORAGE")
definternal(si,  storage_description,       "STORAGE-DESCRIPTION")
definternal(si,  subclassp,                 "SUBCLASSP")
definternal(si,  syntax,                    "SYNTAX")
definternal(si,  syntax_error,              "SYNTAX-ERROR")

// [T]
definternal(si,  table,                     "TABLE")
definternal(si,  test,                      "TEST")
definternal(si,  test_function,             "TEST-FUNCTION")
definternal(si,  thread,                    "THREAD")
definternal(si,  tlv_record,                "TLV-RECORD")
definternal(si,  too_few_arguments,         "TOO-FEW-ARGUMENTS")
definternal(si,  too_many_arguments,        "TOO-MANY-ARGUMENTS")
definternal(si,  too_many_values,           "TOO-MANY-VALUES")
definternal(si,  total_size,                "TOTAL-SIZE")
definternal(si,  types,                     "TYPES")
definternal(si,  type_specifier,            "TYPE-SPECIFIER")
// [U]
definternal(si,  uint,              "UINT")     // foreign type
definternal(si,  uint16,            "UINT16")   // foreign type
definternal(si,  uint32,            "UINT32")   // foreign type
definternal(si,  uint64,            "UINT64")   // foreign type
definternal(si,  uint8,             "UINT8")    // foreign type
definternal(si,  unbound_index,     "UNBOUND-INDEX")
definternal(si,  unbound_marker,    "UNBOUND-MARKER")
definternal(si,  undefined_function_function
    ,"UNDEFINED-FUNCTION-FUNCTION")
definternal(si,  update_obsolte_instance,       "UPDATE-OBSOLTE-INSTANCE")
definternal(si,  uninitialized_funcallable_instance,
    "UNINITIALIZED-FUNCALLABLE-INSTANCE" )
definternal(si,  unparse_pathname,              "UNPARSE-PATHNAME")
defexternal(ext, unrealize_instance,            "UNREALIZE-INSTANCE")
definternal(si,  unquote,                       "UNQUOTE")
definternal(si,  unquote_nsplicing,             "UNQUOTE-NSPLICING")
definternal(si,  unquote_splicing,              "UNQUOTE-SPLICING")
definternal(si,  unrecognized_keyword_argument,
    "UNRECOGNIZED-KEYWORD-ARGUMENT" )
definternal(si,  unsigned_byte_8_vector,        "UNSIGNED-BYTE-8-VECTOR")
definternal(si,  unsigned_byte_16_vector,       "UNSIGNED-BYTE-16-VECTOR")
definternal(si,  unsigned_byte_32_vector,       "UNSIGNED-BYTE-32-VECTOR")
definternal(si,  unsupported_operation,         "UNSUPPORTED-OPERATION")
definternal(si,  update_callers,                "UPDATE-CALLERS")
defexternal(ext, uri,                           "URI")
definternal(si,  used_by_list,                  "USED-BY-LIST")
definternal(si,  use_list,                      "USE-LIST")

// [V]
definternal(si,  value,                      "VALUE")
definternal(si,  value_cell,                 "VALUE-CELL")
definternal(si,  variables,                  "VARIABLES")
definternal(si,  variable_information,       "VARIABLE-INFORMATION")
definternal(si,  vector_object,              "VECTOR-OBJECT")
definternal(si,  version,                    "VERSION")
definternal(si,  void,                       "VOID")  // foreign type

// [W]
definternal(si,  weak_pointer,               "WEAK-POINTER")
definternal(si,  weak_vector_leader,         "WEAK-VECTOR-LEADER")
definternal(si,  whitespace_char_p,          "WHITESPACE-CHAR-p")
definternal(si,  wildcard,                   "WILDCARD")
definternal(si,  writers,                    "WRITERS")

// Compiler related symbols
definternal(c, c_AcontextA,             "*CONTEXT*")
definternal(c, c_AoptionsA,             "*OPTIONS*")
definternal(c, c_Aprocessing_modeA,     "*PROCESSING-MODE*")
definternal(c, c_AsituationA,           "*SITUATION*")
definternal(c, c_call_macro_expander,   "CALL-MACRO-EXPANDER")
definternal(c, compile_form,            "COMPILE-FORM")
definternal(c, literal_cell,            "LITERAL-CELL")
definternal(c, pseudo_class,            "PSEUDO-CLASS")
definternal(c, pseudo_object,           "PSEUDO-OBJECT")
definternal(c, stack_cell,              "STACK-CELL")
definternal(c, c_type_predicate,        "TYPE-PREDICATE")
definternal(c, c_varary,                "VARARY")

definternal(si,  Pdefclass,                  "%DEFCLASS")
definternal(si,  Pdefconstant,               "%DEFCONSTANT")
definternal(si,  Pdefgeneric,                "%DEFGENERIC")
definternal(si,  Pdefine_compiler_macro,     "%DEFINE-COMPILER-MACRO")
definternal(si,  Pdefine_condition,          "%DEFINE-CONDITION")
definternal(si,  Pdefine_method_combination, "%DEFINE-METHOD-COMBINATION")
definternal(si,  Pdefine_modify_macro,       "%DEFINE-MODIFY-MACRO")
definternal(si,  Pdefine_setf_expander,      "%DEFINE-SETF-EXPANDER")
definternal(si,  Pdefine_symbol_macro,       "%DEFINE-SYMBOL-MACRO")
definternal(si,  Pdefmacro,                  "%DEFMACRO")
definternal(si,  Pdefmethod,                 "%DEFMETHOD")
definternal(si,  Pdefpackage,                "%DEFPACKAGE")
definternal(si,  Pdefparameter,              "%DEFPARAMETER")
definternal(si,  Pdefsetf,                   "%DEFSETF")
definternal(si,  Pdefstruct,                 "%DEFSTRUCT")
definternal(si,  Pdeftype,                   "%DEFTYPE")
definternal(si,  Pdefun,                     "%DEFUN")
definternal(si,  Pdefvar,                    "%DEFVAR")
definternal(si,  Pexit_lisp,                 "%EXIT-LISP")

// Intrinsics
// Function names start with "!" are non-standard calling scheme.
definternal(si,  make_closed_cell, "MAKE-CLOSED-CELL")
definternal(si,  valuesA,          "VALUES*")

definternal(si,  BBfuncall,             "!!FUNCALL")
definternal(si,  BAallow_other_keys,    "!&ALLOW-OTHER-KEYS")
definternal(si,  BAkey,                 "!&KEY")
definternal(si,  Barity_error,          "!ARITY-ERROR")
definternal(si,  Bbox_float32,          "!BOX-FLOAT32")
definternal(si,  Bbox_float64,          "!BOX-FLOAT64")
definternal(si,  Bbox_int32,            "!BOX-INT32")
definternal(si,  Bbox_int64,            "!BOX-INT64")
definternal(si,  Bfuncall,              "!FUNCALL")
definternal(si,  Bgo,                   "!GO")
definternal(si,  Bmake_closure,         "!MAKE-CLOSURE")
definternal(si,  Bnot_function,         "!NOT-FUNCTION")
definternal(si,  Brestify,              "!RESTIFY")
definternal(si,  Breturn,               "!RETURN")
definternal(si,  Bstack_restify,        "!STACK-RESTIFY")
definternal(si,  Bthrow,                "!THROW")
definternal(si,  Btlv,                  "!TLV")
definternal(si,  Buninitialized_funcallable_instance, "!UNINITIALIZED-FUNCALLABLE-INSTANCE")
definternal(si,  Bunbox_int32,          "!UNBOX-INT32")
definternal(si,  Bunbox_uint32,         "!UNBOX-UINT32")

definternal(si,  Phandler_case,        "%HANDLER-CASE")
definternal(si,  Ptype_error,          "%TYPE-ERROR")
definternal(si,  Pundefined_function,  "%UNDEFINED-FUNCTION")

#if _WIN32
definternal(si,  windows_host,       "WINDOWS-HOST")
definternal(si,  windows_pathname,   "WINDOWS-PATHNAME")
#endif

// CLOS symbols
defexternal(clos, accessor_method_slot_definition, "ACCESSOR-METHOD-SLOT-DEFINITION")
defexternal(clos, add_dependent, "ADD-DEPENDENT")
defexternal(clos, add_direct_method, "ADD-DIRECT-METHOD")
defexternal(clos, add_direct_subclass, "ADD-DIRECT-SUBCLASS")
defexternal(clos, class_default_initargs, "CLASS-DEFAULT-INITARGS")
defexternal(clos, class_direct_default_initargs, "CLASS-DIRECT-DEFAULT-INITARGS")
defexternal(clos, class_direct_slots, "CLASS-DIRECT-SLOTS")
defexternal(clos, class_direct_subclasses, "CLASS-DIRECT-SUBCLASSES")
defexternal(clos, class_direct_superclasses, "CLASS-DIRECT-SUPERCLASSES")
defexternal(clos, class_finalized_p, "CLASS-FINALIZED-P")
defexternal(clos, class_precedence_list, "CLASS-PRECEDENCE-LIST")
defexternal(clos, class_prototype, "CLASS-PROTOTYPE")
defexternal(clos, class_slots, "CLASS-SLOTS")
defexternal(clos, compute_applicable_methods_using_classes, "COMPUTE-APPLICABLE-METHODS-USING-CLASSES")
defexternal(clos, compute_class_precedence_list, "COMPUTE-CLASS-PRECEDENCE-LIST")
defexternal(clos, compute_default_initargs, "COMPUTE-DEFAULT-INITARGS")
defexternal(clos, compute_discriminating_function, "COMPUTE-DISCRIMINATING-FUNCTION")
defexternal(clos, compute_effective_method, "COMPUTE-EFFECTIVE-METHOD")
defexternal(clos, compute_effective_slot_definition, "COMPUTE-EFFECTIVE-SLOT-DEFINITION")
defexternal(clos, compute_slots, "COMPUTE-SLOTS")
defexternal(clos, direct_slot_definition, "DIRECT-SLOT-DEFINITION")
defexternal(clos, direct_slot_definition_class, "DIRECT-SLOT-DEFINITION-CLASS")
defexternal(clos, effective_slot_definition, "EFFECTIVE-SLOT-DEFINITION")
defexternal(clos, effective_slot_definition_class, "EFFECTIVE-SLOT-DEFINITION-CLASS")
defexternal(clos, ensure_class, "ENSURE-CLASS")
defexternal(clos, ensure_class_using_class, "ENSURE-CLASS-USING-CLASS")
defexternal(clos, ensure_generic_function_using_class, "ENSURE-GENERIC-FUNCTION-USING-CLASS")
defexternal(clos, eql_specializer, "EQL-SPECIALIZER")
defexternal(clos, eql_specializer_object, "EQL-SPECIALIZER-OBJECT")
defexternal(clos, extract_lambda_list, "EXTRACT-LAMBDA-LIST")
defexternal(clos, extract_specializer_names, "EXTRACT-SPECIALIZER-NAMES")
defexternal(clos, finalize_inheritance, "FINALIZE-INHERITANCE")
defexternal(clos, find_method_combination, "FIND-METHOD-COMBINATION")
defexternal(clos, forward_referenced_class, "FORWARD-REFERENCED-CLASS")
defexternal(clos, funcallable_instance_function, "FUNCALLABLE-INSTANCE-FUNCTION")
defexternal(clos, funcallable_standard_class, "FUNCALLABLE-STANDARD-CLASS")
defexternal(clos, funcallable_standard_instance_access, "FUNCALLABLE-STANDARD-INSTANCE-ACCESS")
defexternal(clos, funcallable_standard_object, "FUNCALLABLE-STANDARD-OBJECT")
defexternal(clos, generic_function_argument_precedence_order, "GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER")
defexternal(clos, generic_function_declarations, "GENERIC-FUNCTION-DECLARATIONS")
defexternal(clos, generic_function_lambda_list, "GENERIC-FUNCTION-LAMBDA-LIST")
defexternal(clos, generic_function_method_class, "GENERIC-FUNCTION-METHOD-CLASS")
defexternal(clos, generic_function_method_combination, "GENERIC-FUNCTION-METHOD-COMBINATION")
defexternal(clos, generic_function_methods, "GENERIC-FUNCTION-METHODS")
defexternal(clos, generic_function_name, "GENERIC-FUNCTION-NAME")
defexternal(clos, intern_eql_specializer, "INTERN-EQL-SPECIALIZER")
defexternal(clos, long_method_combination, "LONG-METHOD-COMBINATION")
defexternal(clos, make_method_lambda, "MAKE-METHOD-LAMBDA")
defexternal(clos, map_dependents, "MAP-DEPENDENTS")
defexternal(clos, metaobject, "METAOBJECT")
defexternal(clos, method_function, "METHOD-FUNCTION")
defexternal(clos, method_generic_function, "METHOD-GENERIC-FUNCTION")
defexternal(clos, method_lambda_list, "METHOD-LAMBDA-LIST")
defexternal(clos, method_specializers, "METHOD-SPECIALIZERS")
defexternal(clos, reader_method_class, "READER-METHOD-CLASS")
defexternal(clos, remove_dependent, "REMOVE-DEPENDENT")
defexternal(clos, remove_direct_method, "REMOVE-DIRECT-METHOD")
defexternal(clos, remove_direct_subclass, "REMOVE-DIRECT-SUBCLASS")
defexternal(clos, set_funcallable_instance_function, "SET-FUNCALLABLE-INSTANCE-FUNCTION")
defexternal(clos, short_method_combination, "SHORT-METHOD-COMBINATION")
defexternal(clos, slot_boundp_using_class, "SLOT-BOUNDP-USING-CLASS")
defexternal(clos, slot_definition, "SLOT-DEFINITION")
defexternal(clos, slot_definition_allocation, "SLOT-DEFINITION-ALLOCATION")
defexternal(clos, slot_definition_initargs, "SLOT-DEFINITION-INITARGS")
defexternal(clos, slot_definition_initform, "SLOT-DEFINITION-INITFORM")
defexternal(clos, slot_definition_initfunction, "SLOT-DEFINITION-INITFUNCTION")
defexternal(clos, slot_definition_location, "SLOT-DEFINITION-LOCATION")
defexternal(clos, slot_definition_name, "SLOT-DEFINITION-NAME")
defexternal(clos, slot_definition_readers, "SLOT-DEFINITION-READERS")
defexternal(clos, slot_definition_type, "SLOT-DEFINITION-TYPE")
defexternal(clos, slot_definition_writers, "SLOT-DEFINITION-WRITERS")
defexternal(clos, slot_exists_p_using_class, "SLOT-EXISTS-P-USING-CLASS")
defexternal(clos, slot_makunbound_using_class, "SLOT-MAKUNBOUND-USING-CLASS")
defexternal(clos, slot_value_using_class, "SLOT-VALUE-USING-CLASS")
defexternal(clos, specializer, "SPECIALIZER")
defexternal(clos, specializer_direct_generic_functions, "SPECIALIZER-DIRECT-GENERIC-FUNCTIONS")
defexternal(clos, specializer_direct_methods, "SPECIALIZER-DIRECT-METHODS")
defexternal(clos, standard_accessor_method, "STANDARD-ACCESSOR-METHOD")
defexternal(clos, standard_direct_slot_definition, "STANDARD-DIRECT-SLOT-DEFINITION")
defexternal(clos, standard_effective_slot_definition, "STANDARD-EFFECTIVE-SLOT-DEFINITION")
defexternal(clos, standard_instance_access, "STANDARD-INSTANCE-ACCESS")
defexternal(clos, standard_method_combination, "STANDARD-METHOD-COMBINATION")
defexternal(clos, standard_reader_method, "STANDARD-READER-METHOD")
defexternal(clos, standard_slot_definition, "STANDARD-SLOT-DEFINITION")
defexternal(clos, standard_writer_method, "STANDARD-WRITER-METHOD")
defexternal(clos, update_dependent, "UPDATE-DEPENDENT")
defexternal(clos, validate_superclass, "VALIDATE-SUPERCLASS")
defexternal(clos, writer_method_class, "WRITER-METHOD-CLASS")

// Developer
definternal(devel, Acmdl_levelA, "*CMDL-LEVEL*")
definternal(devel, AconditionA,  "*CONDITION*")

#include "./xml/xml_syms.inc"

#include "./tinycl_end_list.h"
